
/** 
 * 处理 list<map> 类型的集合数据,不保存到storage
 * @param {Object} t
 */

(function(e,t) {
		if ("object" == typeof exports && "object" == typeof module) module.exports._AW =new t();
		else if ("function" == typeof define && define.amd) define(t);	
		else e._AW = new t(); //静态函数库
})(this,function () {
	
		//原名 _AW 改为 _AW
		//数组工具对象
		//实现 对数组的排序,分组,左联接，去重
	
	/**
		 * 私有函数 type==null||type==''||type=='a' 
		 * 升序排列 否则 =='d'倒叙排列
		 * @param {Object} prop
		 * @param {Object} type
		 */
		function sortcompare(prop, type) {
			return function(obj1, obj2) {
				var val1 = obj1[prop];
				var val2 = obj2[prop];				
				var r = 0;
				if (val1 < val2) {
					r = -1;
				} else if (val1 > val2) {
					r = 1;
				}
				if (type == 'd') {
					return 0 - r;
				} else
					return r;
			}
		}

		/**
		 * 根据order by 字段集合  排序table记录
		 * @param {list<map>} table 格式[{},{}]
		 * @param {String} orderby  4种格式 分别表示升序,升序,升序,降序："field1%a,field3,field4%,field2%d"
		 */
		this.sort = function(table, orderby) {
			if (!(table instanceof Array)) return null;
			var sp = orderby.split(',')
			for (var i = sp.length - 1; i >= 0; i--) {
				var j = sp[i].indexOf('%');
				var field = null;
				var hz = null
				if (j > 0) {
					field = sp[i].slice(0, j);
					hz = sp[i].slice(j);
				} else {
					field = sp[i].slice(0);
				}
				if (j > 0 && (hz == '%d' || hz == '%D')) {
					table = table.sort(sortcompare(field, 'd')) //降序排列			
				} else {
					table = table.sort(sortcompare(field)) //升序排列
				}
			}
			return table;
		}


		/**
		 * 模仿select left join 功能 内联接 tb1 主表 ,tb2 子表
		 * 主表和子表连接的字段名必须一致
		 * @param {list<map>} tb1 主表
		 * @param {list<map>} tb2 子表
		 * @param {String} joinstr 连接字段 "字段1=字段1,。。。" 前面为tb1字段，后面是tb2字段
		 */
		this.innerjoin = function(tb1, tb2, joinstr) {
			var a = []
			var b = []
			var joins = _Fun.s.split(joinstr);
			if (joins==null) return null;
			for (var k = 0; k < joins.length; k++) {
				var obj = joins[k].split('=')
				if (obj.length == 2) {
					a.push(obj[0])
					b.push(obj[1])
				}
			}
			var arr = [];
			for (var i = 0; i < tb1.length; i++) {
				var obj1 = tb1[i]
				for (var j = 0; j < tb2.length; j++) {
					var obj2 = tb2[j]
					var flag = 1;
					for (var k = 0; k < a.length; k++) {
						if (obj1[a[k]] != obj2[b[k]]) {
							flag = 0;
							break;
						}
					}
					if (flag == 1) {
						var obj = _Fun.m.merge(obj1, obj2)
						arr.push(obj)
					}
				}
			}
			return arr;
		}
		//如果两张表的字段相同必须提前select
		
		/**
		 * 模仿select left join 功能 左联接 tb1 主表 ,tb2 子表
		 * 主表和子表的连接的字段名必须一致
		 * @param {Array} tb1 主表
		 * @param {Array} tb2 子表
		 * @param {Stirng} joinstr 连接字段 "字段1=字段1,。。。" 字段名必须一致，不一致可以先转化成一致
		 */
		this.leftjoin = function(tb1, tb2, joinstr) {
			var a = []
			var b = []
			var joins = _Fun.s.split(joinstr);
			if (joins==null) return null;
			//拆解 on 字段1=字段2,字段1=字段2,字段1=字段2
			for (var k = 0; k < joins.length; k++) {
				var obj = joins[k].split('=')
				if (obj.length == 2) {
					a.push(obj[0])
					b.push(obj[1])
				}
			}
			var arr = [];
			for (var i = 0; i < tb1.length; i++) {
				var obj1 = tb1[i]
				var neq = true; //假设不会匹配到,如果匹配到 =false
				for (var j = 0; j < tb2.length; j++) {
					var obj2 = tb2[j]
					var flag = 1;
					for (var k = 0; k < a.length; k++) { //所有条件都满足
						if (obj1[a[k]] != obj2[b[k]]) {
							flag = 0; //有一个条件不满足
							break;
						}
					}
					if (flag == 1) {
						var obj = _Fun.m.merge(obj1, obj2)
						arr.push(obj)
						neq = false
					}
				}
				if (neq)
					arr.push(obj1);
			}
			return arr;
		}
	
		/**
		 * 模仿select distinct 功能
		 * 根据fieldstr 对数组中的对象进行去重
		 * @param {array} arr 表示 待去重的数据
		 * @param {String} fieldstr  表示去重的字段 distinct 字段
		 */
		this.distinctArr = function(arr, fieldstr) {
			var arr1 = []
			var fields =_Fun.s.split(fieldstr);
			if (null==fields) return arr;
			for (var i = 0; i < arr.length; i++) {
				var obj1 = arr[i]
				var flag1 = 1
				//console.log( arr1.length)
				for (var j = 0; j < arr1.length; j++) {
					var obj2 = arr1[j]
					if (_Fun.m.equal(obj1, obj2, fields)) { //如果属性值相同
						flag1 = 0
						break;
					} else {
						continue;
					}
				}
				if (flag1 == 1)
					arr1.push(_Fun.m.section(obj1, fields))
			}
			return arr1;
		}



		/**
		 * 模仿group by count 功能
		 * 根据 groupcols 从表记录集合 tarr中 统计 countcols字段 的 count计数，第一个值，最后一个值，最小，最大值，汇总sum值
		 * @param {Array} tarr
		 * @param {String} groupcols group by 后面的字段
		 * @param {String} countcols "field1","field2"..，待统计的字段
		 */
		this.groupby = function(tarr, groupcols, countcols) {
			var arr = this.sort(tarr, groupcols) //先排序
			//		for(var i in arr) {
			//			console.log(JSON.stringify(arr[i]))
			//		}
			var arr1 = [] //
			var fields = groupcols.split(',')
			var cols = countcols.split(',') //统计字段
			var ob1 = null;
			for (var i = 0; i < arr.length; i++) {
				var obj1 = arr[i]
				var flag1 = 1 //分组标志
				//console.log( arr1.length)
				for (var j = 0; j < arr1.length; j++) {
					var obj2 = arr1[j]
					if (_Fun.m.equal(obj1, obj2, fields)) {
						flag1 = 0 //维值相等 继续累加
						for (var k = 0; k < cols.length; k++) {
							var col = cols[k]
							ob1[col]["count"]++;
							ob1[col]["lst"] = obj1[col];
							ob1[col]["sum"] += obj1[col];
							if (ob1[col]["min"] > obj1[col])
								ob1[col]["min"] = obj1[col]
							else if (ob1[col]["max"] < obj1[col])
								ob1[col]["max"] = obj1[col];
						}
					}
				}
				if (flag1 == 1) { //维值不等 新建一条
					ob1 = _Fun.m.section(obj1, fields) //截取部分字段
					//对每个字段进行基本统计
					for (var k = 0; k < cols.length; k++) {
						var col = cols[k]
						ob1[col] = {}
						ob1[col]["count"] = 1;
						ob1[col]["sum"] = obj1[col];
						ob1[col]["min"] = obj1[col];
						ob1[col]["max"] = obj1[col];
						ob1[col]["fst"] = obj1[col];
						ob1[col]["lst"] = obj1[col];
					}
					arr1.push(ob1)
				}
			}
			return arr1;
		}

		/**
		 * 从记录集合中 取出字段为fields的记录，重新组成集合
		 * @param {Array} table 表
		 * @param {Object} fields "field1 field11,field2 field12,field3 field13" 把field1转为field11属性 ,其他一样
		 */
		this.select = function(table, fields) {
			var arr1 = [];
			for (var i = 0; i < table.length; i++) {
				var n1 = this.selectcols(table[i], fields);
				arr1.push(n1)
			}
			//console.log("n1"+JSON.stringify(arr1));
			return arr1;
		}
		/**
		 * 从记录中取出 字段为select的记录 可以重命名为别名
		 * 实现select as 功能.并截取指定列名,无指定不显示
		 * @param {Object} rc 一条记录，map格式
		 * @param {String} select 字段集合
		 */
		this.selectcols = function(rc, select) {
			//console.log("selectcols::"+select);
			if (select == null || select == '') return rc;
			var keys = select.split(',')
			var ar = [] //原字段数组
			var br = [] //新列名数组
			//分解老新列名
			for (var i = 0; i < keys.length; i++) {
				var astr = null;
				if (keys[i].indexOf(':') > -1)
					astr = keys[i].split(':');
				else if (keys[i].indexOf(' ') > -1)
					astr = keys[i].split(' ');
				else if (keys[i].indexOf(' as ') > -1)
					astr = keys[i].split(' as ');
				else
					astr = keys[i];

				if (astr == null) continue;
				if (_IS.isArray(astr)) {
					if (astr[0] in rc) {
						ar.push(astr[0]);
						br.push(astr[1]);
					}
				} else {
					if (astr in rc) {
						ar.push(astr);
						br.push(astr);
					}
				}
			}
			if (ar.length == 0) return;
			var n1 = {} //目标对象
			for (var j = 0; j < ar.length; j++) {
				n1[br[j]] = rc[ar[j]]
			}
			//console.log("n1"+JSON.stringify(n1));
			return n1;
		}
		/**
		 * 从表集合中 根据where 过滤函数返回结果，提取可用的记录，并返回
		 * @param {Array} arr 数据集合
		 * @param {Object} where 过滤条件
		 */
		this.where = function(arr, where) {			
			if (arr.length == 0) return;
			if (undefined ==where|| !where) return arr;
			var arr1 = [] //目标数组
			for (var i = 0; i < arr.length; i++) {
				var em = arr[i];
				if (where) {
					if(where(em)) arr1.push(em);
				}
			}
			return arr1;
		};
		
		//key ='field(','field)','field[','field]','field=','field%','or'
		//,'field[%','field%]' 数组和map 不允许用特殊符号表示大小比较和模糊匹配
		//每条记录的属性与条件进行判断
		this.exist=function (rc, whereobj) {
			if(rc instanceof Array && rc.length > 0) {
				return false;
			}
			if(whereobj == null) {
				return true;
			}
			if(whereobj instanceof Array && whereobj.length > 0) {
				for(var i = 0; i < whereobj.length; i++) {
					//for(var i in whereobj) {
					//console.log(JSON.stringify(whereobj[i]))
					var r = reduce(rc, whereobj[i]);
					if(r) return true;
				}
				//console.log("dd "+JSON.stringify(whereobj))
				return false;
			} else {
				if(typeof(whereobj) === 'string') { //不支持 string 类型的条件
					return true;
				}
				for(var key in whereobj) {
					var v = whereobj[key];
		
					if(v == null || v === '') continue; //如果查询的值为空跳过
					//	console.log(key +' '+v+' '+rcv)
		
					if(key == "or") {
						//此时的wvalue=[条件]
						if(v instanceof Array && v.length > 0)
							return reduce(rc, v);
					} else {
						var m = '=';
						var n = 0;
						if((n = key.indexOf('=')) > 0)
							m = '=';
						else if((n = key.indexOf('(')) > 0)
							m = '(';
						else if((n = key.indexOf(')')) > 0)
							m = ')';
						else if((n = key.indexOf('[%')) > 0)
							m = '[%';
						else if((n = key.indexOf('%]')) > 0)
							m = '%]';
						else if((n = key.indexOf('[')) > 0)
							m = '[';
						else if((n = key.indexOf(']')) > 0)
							m = ']';
						else if((n = key.indexOf('%')) > 0)
							m = '%';
		
						if(n == -1)
							n = key.length;
		
						key = key.slice(0, n).replace(/(^\s*)|(\s*$)/g, "");
						var rcv = rc[key];
						if(_IS.isArray(rcv) || _IS.isMap(rcv)) continue; //如果是数组或者map类型跳过
		
						//console.log(key+' '+rcv+m+' '+v)
		
						if(typeof(rcv) == "undefined") {
							return false;
						} else if(typeof(rcv) == 'string') {
							//console.log(m + ' '+typeof(rcv) +' ' + rcv+' '+v+rcv.indexOf(v) )
							if((m == '=' && rcv == v) ||
								(m == '%' && rcv.indexOf(v) > -1) ||
								(m == '[%' && rcv.indexOf(v) == 0) ||
								(m == '%]' && rcv.slice(-v.length) == v) ||
								(m == '(' && rcv > v) || (m == ')' && rcv < v) ||
								(m == '[' && rcv >= v) || (m == ']' && rcv <= v)) {
								continue;
							} else {
								return false;
							}
						} else if(typeof(rcv) === 'number') {
							if((m == '=' && rcv == v) || (m == '(' && rcv > v) ||
								(m == ')' && rcv < v) || (m == '[' && rcv >= v) ||
								(m == ']' && rcv <= v)) {
								//console.log(key+' '+rcv+' '+m+' '+v)
								continue;
							} else {
								return false;
							}
						} else if(_IS.isBool(rcv)) {
							if((m == '=' && rcv == v)) {
								continue;
							} else {
								return false;
							}
						} else {
							console.log('条件表达式错误请检查')
							continue;
						}
					}
				}
				//console.log('ok'+key)
				return true;
			}
		}
		 
	}
);
